home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / benchmarks / pdevtest / client.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-10-24  |  5.7 KB  |  271 lines
  1. /* 
  2.  * client.c --
  3.  *
  4.  *    The client part of a pseudo-device benchmark.
  5.  *    The routines here interface to the server; initial contact,
  6.  *    waiting for the start message, and notification of completion.
  7.  *
  8.  * Copyright 1986 Regents of the University of California
  9.  * All rights reserved.
  10.  */
  11.  
  12. #ifndef lint
  13. static char rcsid[] = "$Header: /sprite/src/benchmarks/pdevtest/RCS/client.c,v 1.2 89/10/24 12:37:46 brent Exp $ SPRITE (Berkeley)";
  14. #endif not lint
  15.  
  16.  
  17. #include "sprite.h"
  18. #include "status.h"
  19. #include "errno.h"
  20. #include "stdio.h"
  21. #include "fs.h"
  22. #include "sys/file.h"
  23. #include "dev/pdev.h"
  24.  
  25. extern char *pdev;
  26. extern Boolean selectP;
  27.  
  28. static char buffer[4096];
  29. static int bufSize = sizeof(buffer);
  30.  
  31. typedef struct ClientState {
  32.     int clientStreamID;
  33. } ClientState;
  34.  
  35. /*
  36.  *----------------------------------------------------------------------
  37.  *
  38.  * ClientSetup --
  39.  *
  40.  *    Establish contact with the server.
  41.  *
  42.  * Results:
  43.  *    A pointer to state about the clients needed by ClientStart and
  44.  *    ClientDone.
  45.  *
  46.  * Side effects:
  47.  *    Creates named pipes and communicates with server
  48.  *    This exits upon error.
  49.  *
  50.  *----------------------------------------------------------------------
  51.  */
  52.  
  53. void
  54. ClientSetup(dataPtr)
  55.     ClientData *dataPtr;
  56. {
  57.     ClientState *statePtr;
  58.     ReturnStatus status;
  59.  
  60.     statePtr = (ClientState *)malloc(sizeof(ClientState));
  61.  
  62.     statePtr->clientStreamID = open(pdev, O_RDWR, 0);
  63.     if (statePtr->clientStreamID < 0) {
  64.     perror(pdev);
  65.     exit(errno);
  66.     }
  67.     *dataPtr = (ClientData)statePtr;
  68. }
  69.  
  70. /*
  71.  *----------------------------------------------------------------------
  72.  *
  73.  * ClientRead --
  74.  *
  75.  *    Read from a pseudo-device.  The amount and number of repetitions
  76.  *    can be varied for measurment.
  77.  *
  78.  * Results:
  79.  *    None
  80.  *
  81.  * Side effects:
  82.  *    None.
  83.  *
  84.  *----------------------------------------------------------------------
  85.  */
  86.  
  87. void
  88. ClientRead(data, size, reps)
  89.     ClientData data;
  90.     int size;
  91.     register int reps;
  92. {
  93.     ClientState *statePtr;
  94.     int amountRead;
  95.     register ReturnStatus status;
  96.     register char *bufPtr;
  97.     register int i;
  98.  
  99.     if (size > bufSize) {
  100.     bufPtr = (char *)malloc(size);
  101.     } else {
  102.     bufPtr = buffer;
  103.     }
  104.     statePtr = (ClientState *)data;
  105.     for (i=0 ; i<reps ; i++) {
  106.     amountRead = size;
  107.     if (selectP) {
  108.         int numReady;
  109.         int mask = 1 << statePtr->clientStreamID;
  110.         status = Fs_Select(32, NULL, &mask, NULL, NULL, &numReady);
  111.         if (status != SUCCESS) {
  112.         Stat_PrintMsg(status, "ClientRead: error on select");
  113.         break;
  114.         }
  115.     }
  116.     amountRead = read(statePtr->clientStreamID, bufPtr, size);
  117.     if (amountRead < 0) {
  118.         perror("ClientRead: error on read");
  119.         break;
  120.     } else if (amountRead != size) {
  121.         fprintf(stderr, "Read #%d was short (%d < %d)\n",
  122.             i, amountRead, size);
  123.         break;
  124.     }
  125.     if (size > 0 && bufPtr[0] != 'z') {
  126.         fprintf(stderr, "Bad data returned <%c>\n", bufPtr[0]);
  127.     }
  128.     }
  129.     if (bufPtr != buffer) {
  130.     free((char *)bufPtr);
  131.     }
  132. }
  133.  
  134. /*
  135.  *----------------------------------------------------------------------
  136.  *
  137.  * ClientWrite --
  138.  *
  139.  *    Write to a pseudo-device.  The amount and number of repetitions
  140.  *    can be varied for measurment.
  141.  *
  142.  * Results:
  143.  *    None
  144.  *
  145.  * Side effects:
  146.  *    None.
  147.  *
  148.  *----------------------------------------------------------------------
  149.  */
  150.  
  151. void
  152. ClientWrite(data, size, reps)
  153.     ClientData data;
  154.     int size;
  155.     register int reps;
  156. {
  157.     ClientState *statePtr;
  158.     int amountWrite;
  159.     register ReturnStatus status;
  160.     register char *bufPtr;
  161.  
  162.     if (size > bufSize) {
  163.     bufPtr = (char *)malloc(size);
  164.     } else {
  165.     bufPtr = buffer;
  166.     }
  167.     statePtr = (ClientState *)data;
  168.     do {
  169.     amountWrite = write(statePtr->clientStreamID, bufPtr, size);
  170.     if (amountWrite < 0) {
  171.         perror("ClientWrite: error on write");
  172.         break;
  173.     } else if (amountWrite != size) {
  174.         fprintf(stderr, "Short write %d < %d\n", amountWrite,
  175.                     size);
  176.     }
  177.     } while (--reps > 0);
  178.     if (bufPtr != buffer) {
  179.     free((char *)bufPtr);
  180.     }
  181. }
  182.  
  183. /*
  184.  *----------------------------------------------------------------------
  185.  *
  186.  * ClientIOControl --
  187.  *
  188.  *    Do an IOControl to a pseudo-device.
  189.  *    The amount of data passed in and number of repetitions
  190.  *    can be varied for measurment.
  191.  *
  192.  * Results:
  193.  *    None
  194.  *
  195.  * Side effects:
  196.  *    None.
  197.  *
  198.  *----------------------------------------------------------------------
  199.  */
  200.  
  201. void
  202. ClientIOControl(data, size, reps)
  203.     ClientData data;
  204.     int size;
  205.     register int reps;
  206. {
  207.     ClientState *statePtr;
  208.     int amountRead;
  209.     register ReturnStatus status;
  210.     register char *inBuffer;
  211.     register char *outBuffer;
  212.     int command;
  213.  
  214.     if (size > bufSize) {
  215.     inBuffer = (char *)malloc(size);
  216.     outBuffer = (char *)malloc(size);
  217.     } else {
  218.     inBuffer = outBuffer = buffer;
  219.     }
  220.     statePtr = (ClientState *)data;
  221.     do {
  222.     extern Boolean switchBuf;
  223.     if (switchBuf && (reps % 7) == 0) {
  224.         command = IOC_PDEV_SET_BUF;
  225.     } else {
  226.         command = 8 << 16;    /* To avoid range of generic I/O controls */
  227.     }
  228.     status = Fs_IOControl(statePtr->clientStreamID, command, size, inBuffer,
  229.                 size, outBuffer);
  230.     if (status != SUCCESS) {
  231.         Stat_PrintMsg(status, "ClientIOControl: error ");
  232.         break;
  233.     }    
  234.     } while (--reps > 0);
  235.     if (inBuffer != buffer) {
  236.     free((char *)inBuffer);
  237.     free((char *)outBuffer);
  238.     }
  239. }
  240.  
  241. /*
  242.  *----------------------------------------------------------------------
  243.  *
  244.  * ClientDone --
  245.  *
  246.  *    Tell the server we're done.  This is just done by closing
  247.  *    the pseudo stream.
  248.  *
  249.  * Results:
  250.  *    None
  251.  *
  252.  * Side effects:
  253.  *    None
  254.  *
  255.  *----------------------------------------------------------------------
  256.  */
  257.  
  258. void
  259. ClientDone(data)
  260.     ClientData data;
  261. {
  262.     ClientState *statePtr;
  263.     register ReturnStatus status;
  264.  
  265.     statePtr = (ClientState *)data;
  266.     if (close(statePtr->clientStreamID) < 0) {
  267.     perror("ClientDone: error on close");
  268.     }
  269.     free((char *)statePtr);
  270. }
  271.